[TRACK_B] Route the last pure builtins — three defects, a false doc promise, and the first conditional prelude - #75

REQ-70. Every builtin family is now routed: 341 of 373 compile, up from 323.

I described these 26 as unexamined backlog. That framing was wrong, and so was my earlier claim that the remaining interpreter-only set each had a stated reason — only 24 of 50 did. Examining the other 26 found three defects rather than missing implementations.

Three defects, not a backlog

A language feature did not compile. adalah_kiri/adalah_kanan/nilai_kiri/nilai_kanan are not stdlib functions a user calls — they are compiler internals. The parser's if-chain pattern compiler emits them for a constructor pattern nested where a Case cannot go, such as (Ada(a), Tiada) inside a tuple pattern. Unrouted, that entire class of pattern ran under riinac run and failed riinac build with Codegen Error: unbound variable: nilai_kiri. Four obscure interp-only rows were in fact one missing feature in the compiled backend.

baki/rem were uncallable from any well-typed program. They are binary and take a pair — the interpreter's extract_pair_ints and the emitted C's RIINA_TAG_PAIR check both say so — but the typechecker declared them Nombor -> Nombor, because they shared a registration loop with the genuinely unary log2. So baki(10, 3) failed with "Expected function type, found Int" and baki((10, 3)) failed with "expected Int, found Prod(Int, Int)". Two of three components agreed; the type was the outlier, so the type is what changed.

cetak_baris was a pure aliasing gap. The interpreter binds cetakln, println and cetak_baris to one Value::Builtin("cetakln"). Only builtin_canonical knew two of the three.

baki, log2 and rawak already had C sitting unreferenced in emit.rs, exactly like the json helpers before them.

The Backend column was making a false promise

interp-only reads "riinac run only". For the eight crypto-agility builtins (guna_kripto/use_crypto, pilih_algo/select_algorithm, cipher/sifer, hash_dengan/hash_with) that was false: they sit in the typechecker registry with Fn(Teks, Any, Kripto) and carry the REQ-48 deprecation check at their call sites, but no runtime binds them. Verified by command for all eight — riinac run fails with unbound variable exactly as riinac build does.

A three-state column had no way to say "typed but unimplemented", so it said the nearest thing. Added a fourth state typed-only, derived from a new riina_codegen::interpreter_supports_builtin that builds the real interpreter environment and looks the name up — not from a list, which would drift the moment a runtime is added.

The Unicode three needed the emitter's first conditional prelude block

nfc, skeleton and adalah_keliru need ~250 KB of vendored UCD tables. The prelude is already ~228 KB for a hello-world and is otherwise entirely unconditional, so emitting the tables always would more than double every compiled binary to serve three builtins most programs never call. emit() now scans the IR and emits the block only on a call.

Measured: hello-world stays 229,600 bytes with zero tables; a program calling nfc gets 492,515.

The C tables are generated from the same Rust statics the interpreter reads, not transcribed. A hand-copied 250 KB table is a drift source no differential could realistically cover; generating it means the backends cannot disagree about the data at all — only about the ~150-line algorithm, which is what the tests exercise.

A negative control caught a test passing for the wrong reason

The composition-blocking case was first written as a + dot-below + acute. Deleting the blocking condition from the emitted C did not make it fail — there both marks compose into the starter in turn, so blocking never applies.

Rewritten as a + U+0305 overline + U+0301 acute: equal combining classes, and the overline does not compose, so removing the check composes a+acute across the overline and shortens the result from five bytes to four. Re-ran the control; the test then failed as intended. The reasoning is recorded in the test's own comment so the input is not "simplified" back later.

keselamatan_nama.rii now compiles

One of the four Gate C sample apps, and the only one that would not build. Verified by command, with output byte-identical to riinac run.

What remains, and why

Every remaining interp-only builtin has a stated reason:

The 8 typed-only crypto-agility builtins need a runtime, not routing — separate work, and not REQ-70's to close.

Tests

• pure_builtin_differential.rs — 6 cases. The load-bearing one is the nested constructor pattern, ordered so a failing tag test precedes a succeeding one, plus a separate case asserting the bound payload matches (a nilai_kiri returning the sum rather than its contents would still pick the right arm and print the wrong number).
• unicode_differential.rs — 7 cases, chosen where the algorithm decides rather than the data: Hangul (arithmetic, in no table), stable canonical ordering, the blocking rule above, and that skeleton ends in NFD rather than NFC. Plus hello_world_carries_no_ucd_tables, which keeps the conditional-emission promise honest — without it the block would silently become unconditional again and nothing else would notice.
• rawak/random is routed despite the backends being uncomparable by output (both time-seeded). The differential pins the range invariant and says plainly that equality is not checked. Routing is still right: without it a compiled RIINA program has no source of randomness at all. Neither implementation is a CSPRNG and neither claims to be.

Verification

• 03_PROTO: 3373 passing, 0 failed (+13)
• 05_TOOLING: 323 passing, 0 failed
• cargo clippy -- -D warnings: clean on both workspaces
• scripts/audit-docs.sh: 0 discrepancies (2 pre-existing warnings, unrelated)
• docs/api/STDLIB.md regenerated from the compiler — counts re-derived, not carried forward

🤖 Generated with Claude Code

https://claude.ai/code/session_01Uu28z8CdRQ1SLzTv8yszth

Generated by Claude Code